GridActions.js ➔ getAsyncData - Code Metrics - Inspection of "update all actions to use fat arrow" - bencripps/react-redux-grid - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 55f45f...84a66e )

by Benjamin

created 2016-10-14 15:22 UTC

GridActions.js ➔ getAsyncData B

↳ Parent: src/actions/GridActions.js

Complexity

Conditions	1
Paths	16

Size

Total Lines

164

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
c	0
b	0
f	0
nc	16
dl	0
loc	164
rs	8.2857
nop	1

2 Functions

Rating	Name	Duplication	Size	Complexity
B	GridActions.js ➔ ... ➔ ???	0	157	4
B	GridActions.js ➔ ... ➔ ???	0	64	6

How to fix Long Method

import {
    ERROR_OCCURRED,
    HIDE_HEADER,
    MOVE_NODE,
    RESIZE_COLUMNS,
    SET_COLUMNS,
    SET_DATA,
    SET_SORT_DIRECTION,
    SET_TREE_DATA_PARTIAL,
    SET_TREE_NODE_VISIBILITY,
    SORT_DATA
} from '../constants/ActionTypes';

import { setLoaderState } from '../actions/plugins/loader/LoaderActions';

import { dismissEditor } from '../actions/plugins/editor/EditorActions';

import { keyGenerator } from '../util/keyGenerator';

import { treeToFlatList } from '../util/treeToFlatList';

import Request from '../components/plugins/ajax/Request';

export const getAsyncData = ({
    stateKey, dataSource, type, showTreeRootNode, extraParams = {}
}) => {

    return (dispatch) => {

        dispatch(dismissEditor({ stateKey }));

        dispatch(
            setLoaderState({state: true, stateKey })
        );

        if (typeof dataSource === 'function') {

            // passing extraParams.parentId
            // to custom func so they can do partial
            // loading
            dataSource(extraParams).then((response) => {

                if (response && response.data) {

                    dispatch(
                        setLoaderState({ state: false, stateKey })
                    );

                    if (type !== 'tree') {

                        dispatch({
                            type: SET_DATA,
                            data: response.data,
                            total: response.total,
                            currentRecords: response.data,
                            success: true,
                            stateKey,
                            editMode: extraParams.editMode
                        });
                    }

                    else {
                        // upon the return of read
                        // response needs to clarify
                        // whether this is a partial update
                        dispatch(setTreeData({
                            data: response.data,
                            stateKey,
                            showTreeRootNode,
                            parentId: extraParams.parentId,
                            partial: response.partial,
                            editMode: extraParams.editMode
                        }));
                    }

                    return;
                }

                if (response && !response.data) {
                    /* eslint-disable no-console */
                    console.warn(
                        `A response was recieved
                         but no data entry was found`
                    );
                    console.warn(
                        `Please see
                         https://github.com/bencripps/react-redux-grid
                         for documentation`
                    );
                    /* eslint-enable no-console */
                }

                dispatch(
                    setLoaderState({ state: false, stateKey })
                );

                dispatch({
                    type: ERROR_OCCURRED,
                    error: 'Unable to Retrieve Grid Data',
                    errorOccurred: true,
                    stateKey
                });

            });

        }

        else if (typeof dataSource === 'string') {
function isBig(a) {
    if (a > 5000) {
        return "yes";
    }
}

console.log(isBig(5001)); //returns yes
console.log(isBig(42)); //returns undefined

            if (type !== 'tree') {

                return Request.api({
                    route: dataSource,
                    method: 'GET'
                }).then((response) => {

                    if (response && response.data) {

                        dispatch({
                            type: SET_DATA,
                            data: response.data,
                            total: response.total,
                            currentRecords: response.data,
                            success: true,
                            stateKey,
                            editMode: extraParams.editMode
                        });

                    }

                    else {
                        dispatch({
                            type: ERROR_OCCURRED,
                            error: 'Unable to Retrieve Grid Data',
                            errorOccurred: true,
                            stateKey
                        });
                    }

                    dispatch(
                        setLoaderState({state: false, stateKey })
                    );
                });

            }

            return Request.api({
                route: dataSource,
                method: 'GET',
                queryStringParams: {
                    parentId: extraParams.parentId
                }
            }).then((response) => {

                if (response && response.data) {

                    // response needs to specify
                    // whether this is full or partial update
                    dispatch(setTreeData({
                        data: response.data,
                        stateKey,
                        showTreeRootNode,
                        partial: response.partial,
                        parentId: extraParams.parentId
                    }));

                }

                else {
                    dispatch({
                        type: ERROR_OCCURRED,
                        error: 'Unable to Retrieve Grid Data',
                        errorOccurred: true,
                        stateKey
                    });
                }

                dispatch(
                    setLoaderState({state: false, stateKey })
                );
            });

        }

    };
};

export const setColumns = ({ columns, stateKey, stateful }) => {

    let cols = columns;

    if (!cols[0].id) {
        cols = columns.map((col) => {
            col.id = keyGenerator(col.name, 'grid-column');
            return col;
        });
    }

    return { type: SET_COLUMNS, columns: cols, stateKey, stateful };
};

export const setSortDirection = ({
    columns, id, sortDirection, stateKey
}) => {

    let cols = columns;


    cols = columns.map((col) => {

        if (col.id === id) {
            col.sortDirection = sortDirection;
        }

        else {
            // to do: remove this if we want to build
            // up the sorts
            col.sortDirection = null;
        }

        return col;
    });

    return { type: SET_SORT_DIRECTION, columns: cols, stateKey };
};

export const doLocalSort = ({ data, stateKey }) => ({
    type: SORT_DATA, data, stateKey
});

export const doRemoteSort = ({
    dataSource, pageIndex, pageSize, sortParams, stateKey
}) => {

    return (dispatch) => {

        dispatch(
            setLoaderState({state: true, stateKey })
        );


        if (typeof dataSource === 'function') {
            return dataSource({}, {}, sortParams).then((response) => {

                if (response && response.data) {

                    dispatch({
                        type: SET_DATA,
                        data: response.data,
                        total: response.total,
                        currentRecords: response.data,
                        success: true,
                        stateKey
                    });

                }

                else {

                    if (response && !response.data) {
                        /* eslint-disable no-console */
                        console.warn(
                            `A response was recieved but no data
                             entry was found`
                        );
                        console.warn(
                            `Please see
                             https://github.com/bencripps/react-redux-grid
                             for documentation`
                        );
                        /* eslint-enable no-console */
                    }

                    dispatch({
                        type: ERROR_OCCURRED,
                        error: 'Unable to Retrieve Grid Data',
                        errorOccurred: true,
                        stateKey
                    });
                }

                dispatch(
                    setLoaderState({state: false, stateKey })
                );
            });

        }

        return Request.api({
            route: dataSource,
            method: 'POST',
            data: {
                pageIndex: pageIndex,
                pageSize: pageSize,
                sort: sortParams.sort
            }
        }).then((response) => {

            if (response && response.data) {

                dispatch({
                    type: SET_DATA,
                    data: response.data,
                    total: response.total,
                    currentRecords: response.data,
                    success: true
                });

            }

            else {
                dispatch({
                    type: ERROR_OCCURRED,
                    error: 'Unable to Retrieve Grid Data',
                    errorOccurred: true
                });
            }

            dispatch(
                setLoaderState({state: false, stateKey })
            );
        });

    };
};

export const setColumnVisibility = ({
 columns, column, isHidden, stateKey, stateful
}) => {
    const hidden = !isHidden;

    const columnsArr = columns.map((col) => {
        if (col.name === column.name) {
            col.hidden = hidden;
        }

        return col;
    });

    return { type: SET_COLUMNS, columns: columnsArr, stateKey, stateful };
};

export const resizeColumns = ({
    width, id, nextColumn, columns, stateKey, stateful
}) => {

    const cols = columns.map((col) => {

        if (col.id === id) {
            col.width = `${width}%`;
        }

        else if (col.id === nextColumn.id) {
            col.width = `${nextColumn.width}%`;
        }

        return col;

    });

    return {
        type: RESIZE_COLUMNS,
        stateKey,
        columns: cols,
        stateful
    };

};

export const setData = ({ data, stateKey, editMode }) => ({
    type: SET_DATA, data, stateKey, editMode
});

export const setTreeData = ({
    data, stateKey, showTreeRootNode, partial, parentId, editMode
}) => {

    // if this is a partial update to
    // a tree grid, dispatch separate action;
    if (partial) {
        return {
            type: SET_TREE_DATA_PARTIAL,
            data: data,
            stateKey,
            gridType: 'tree',
            showTreeRootNode,
            parentId
        };
    }

    let flat = treeToFlatList(data);

    // remove root node
    if (!showTreeRootNode) {
        flat = flat.shift();
    }

    return {
        type: SET_DATA,
        data: flat,
        stateKey,
        gridType: 'tree',
        treeData: data,
        editMode
    };
};

export const setTreeNodeVisibility = ({
    id, visible, stateKey, showTreeRootNode
}) => ({
    type: SET_TREE_NODE_VISIBILITY,
    id,
    visible,
    stateKey,
    showTreeRootNode
});

export const moveNode = ({
    stateKey, current, next, showTreeRootNode
}) => ({
    type: MOVE_NODE,
    stateKey,
    current,
    next,
    showTreeRootNode
});

export const setHeaderVisibility = ({ hidden, stateKey }) => ({
    type: HIDE_HEADER, headerHidden: hidden, stateKey
});


1		import {
2		ERROR_OCCURRED,
3		HIDE_HEADER,
4		MOVE_NODE,
5		RESIZE_COLUMNS,
6		SET_COLUMNS,
7		SET_DATA,
8		SET_SORT_DIRECTION,
9		SET_TREE_DATA_PARTIAL,
10		SET_TREE_NODE_VISIBILITY,
11		SORT_DATA
12		} from '../constants/ActionTypes';
13
14		import { setLoaderState } from '../actions/plugins/loader/LoaderActions';
15
16		import { dismissEditor } from '../actions/plugins/editor/EditorActions';
17
18		import { keyGenerator } from '../util/keyGenerator';
19
20		import { treeToFlatList } from '../util/treeToFlatList';
21
22		import Request from '../components/plugins/ajax/Request';
23
24		export const getAsyncData = ({
25		stateKey, dataSource, type, showTreeRootNode, extraParams = {}
26		}) => {
27
28		return (dispatch) => {
29
30		dispatch(dismissEditor({ stateKey }));
31
32		dispatch(
33		setLoaderState({state: true, stateKey })
34		);
35
36		if (typeof dataSource === 'function') {
37
38		// passing extraParams.parentId
39		// to custom func so they can do partial
40		// loading
41		dataSource(extraParams).then((response) => {
42
43		if (response && response.data) {
44
45		dispatch(
46		setLoaderState({ state: false, stateKey })
47		);
48
49		if (type !== 'tree') {
50
51		dispatch({
52		type: SET_DATA,
53		data: response.data,
54		total: response.total,
55		currentRecords: response.data,
56		success: true,
57		stateKey,
58		editMode: extraParams.editMode
59		});
60		}
61
62		else {
63		// upon the return of read
64		// response needs to clarify
65		// whether this is a partial update
66		dispatch(setTreeData({
67		data: response.data,
68		stateKey,
69		showTreeRootNode,
70		parentId: extraParams.parentId,
71		partial: response.partial,
72		editMode: extraParams.editMode
73		}));
74		}
75
76		return;
77		}
78
79		if (response && !response.data) {
80		/* eslint-disable no-console */
81		console.warn(
82		`A response was recieved
83		but no data entry was found`
84		);
85		console.warn(
86		`Please see
87		https://github.com/bencripps/react-redux-grid
88		for documentation`
89		);
90		/* eslint-enable no-console */
91		}
92
93		dispatch(
94		setLoaderState({ state: false, stateKey })
95		);
96
97		dispatch({
98		type: ERROR_OCCURRED,
99		error: 'Unable to Retrieve Grid Data',
100		errorOccurred: true,
101		stateKey
102		});
103
104		});
		0 ignored issues – show Best Practice introduced 2016-08-21 15:46 UTC by Report Bug Copy Issue Report There is no `return` statement in this branch, but you do return something in other branches. Did you maybe miss it? If you do not want to return anything, consider adding `return undefined;` explicitly. Loading history...
105		}
106
107		else if (typeof dataSource === 'string') {
		0 ignored issues – show Complexity Best Practice introduced 2016-08-21 15:46 UTC by Report Bug Copy Issue Report There is no return statement if `typeof dataSource === "string"` is `false`. Are you sure this is correct? If so, consider adding `return;` explicitly. This check looks for functions where a `return` statement is found in some execution paths, but not in all. Consider this little piece of code function isBig(a) { if (a > 5000) { return "yes"; } } console.log(isBig(5001)); //returns yes console.log(isBig(42)); //returns undefined The function `isBig` will only return a specific value when its parameter is bigger than 5000. In any other case, it will implicitly return `undefined`. This behaviour may not be what you had intended. In any case, you can add a `return undefined` to the other execution path to make the return value explicit. Loading history...
108
109		if (type !== 'tree') {
110
111		return Request.api({
112		route: dataSource,
113		method: 'GET'
114		}).then((response) => {
115
116		if (response && response.data) {
117
118		dispatch({
119		type: SET_DATA,
120		data: response.data,
121		total: response.total,
122		currentRecords: response.data,
123		success: true,
124		stateKey,
125		editMode: extraParams.editMode
126		});
127
128		}
129
130		else {
131		dispatch({
132		type: ERROR_OCCURRED,
133		error: 'Unable to Retrieve Grid Data',
134		errorOccurred: true,
135		stateKey
136		});
137		}
138
139		dispatch(
140		setLoaderState({state: false, stateKey })
141		);
142		});
143
144		}
145
146		return Request.api({
147		route: dataSource,
148		method: 'GET',
149		queryStringParams: {
150		parentId: extraParams.parentId
151		}
152		}).then((response) => {
153
154		if (response && response.data) {
155
156		// response needs to specify
157		// whether this is full or partial update
158		dispatch(setTreeData({
159		data: response.data,
160		stateKey,
161		showTreeRootNode,
162		partial: response.partial,
163		parentId: extraParams.parentId
164		}));
165
166		}
167
168		else {
169		dispatch({
170		type: ERROR_OCCURRED,
171		error: 'Unable to Retrieve Grid Data',
172		errorOccurred: true,
173		stateKey
174		});
175		}
176
177		dispatch(
178		setLoaderState({state: false, stateKey })
179		);
180		});
181
182		}
183
184		};
185		};
186
187		export const setColumns = ({ columns, stateKey, stateful }) => {
188
189		let cols = columns;
190
191		if (!cols[0].id) {
192		cols = columns.map((col) => {
193		col.id = keyGenerator(col.name, 'grid-column');
194		return col;
195		});
196		}
197
198		return { type: SET_COLUMNS, columns: cols, stateKey, stateful };
199		};
200
201		export const setSortDirection = ({
202		columns, id, sortDirection, stateKey
203		}) => {
204
205		let cols = columns;
		0 ignored issues – show Unused Code introduced 2016-09-08 18:04 UTC by Report Bug Copy Issue Report The assignment to variable `cols` seems to be never used. Consider removing it. Loading history...
206
207		cols = columns.map((col) => {
208
209		if (col.id === id) {
210		col.sortDirection = sortDirection;
211		}
212
213		else {
214		// to do: remove this if we want to build
215		// up the sorts
216		col.sortDirection = null;
217		}
218
219		return col;
220		});
221
222		return { type: SET_SORT_DIRECTION, columns: cols, stateKey };
223		};
224
225		export const doLocalSort = ({ data, stateKey }) => ({
226		type: SORT_DATA, data, stateKey
227		});
228
229		export const doRemoteSort = ({
230		dataSource, pageIndex, pageSize, sortParams, stateKey
231		}) => {
232
233		return (dispatch) => {
234
235		dispatch(
236		setLoaderState({state: true, stateKey })
237	View Code Duplication	);
		0 ignored issues – show Duplication introduced 2016-08-21 15:46 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
238
239		if (typeof dataSource === 'function') {
240		return dataSource({}, {}, sortParams).then((response) => {
241
242		if (response && response.data) {
243
244		dispatch({
245		type: SET_DATA,
246		data: response.data,
247		total: response.total,
248		currentRecords: response.data,
249		success: true,
250		stateKey
251		});
252
253		}
254
255		else {
256
257		if (response && !response.data) {
258		/* eslint-disable no-console */
259		console.warn(
260		`A response was recieved but no data
261		entry was found`
262		);
263		console.warn(
264		`Please see
265		https://github.com/bencripps/react-redux-grid
266		for documentation`
267		);
268		/* eslint-enable no-console */
269		}
270
271		dispatch({
272		type: ERROR_OCCURRED,
273		error: 'Unable to Retrieve Grid Data',
274		errorOccurred: true,
275		stateKey
276		});
277		}
278
279		dispatch(
280		setLoaderState({state: false, stateKey })
281		);
282		});
283
284		}
285
286		return Request.api({
287		route: dataSource,
288		method: 'POST',
289		data: {
290		pageIndex: pageIndex,
291		pageSize: pageSize,
292		sort: sortParams.sort
293		}
294		}).then((response) => {
295
296		if (response && response.data) {
297
298		dispatch({
299		type: SET_DATA,
300		data: response.data,
301		total: response.total,
302		currentRecords: response.data,
303		success: true
304		});
305
306		}
307
308		else {
309		dispatch({
310		type: ERROR_OCCURRED,
311		error: 'Unable to Retrieve Grid Data',
312		errorOccurred: true
313		});
314		}
315
316		dispatch(
317		setLoaderState({state: false, stateKey })
318		);
319		});
320
321		};
322		};
323
324		export const setColumnVisibility = ({
325		columns, column, isHidden, stateKey, stateful
326		}) => {
327		const hidden = !isHidden;
328
329		const columnsArr = columns.map((col) => {
330		if (col.name === column.name) {
331		col.hidden = hidden;
332		}
333
334		return col;
335		});
336
337		return { type: SET_COLUMNS, columns: columnsArr, stateKey, stateful };
338		};
339
340		export const resizeColumns = ({
341		width, id, nextColumn, columns, stateKey, stateful
342		}) => {
343
344		const cols = columns.map((col) => {
345
346		if (col.id === id) {
347		col.width = `${width}%`;
348		}
349
350		else if (col.id === nextColumn.id) {
351		col.width = `${nextColumn.width}%`;
352		}
353
354		return col;
355
356		});
357
358		return {
359		type: RESIZE_COLUMNS,
360		stateKey,
361		columns: cols,
362		stateful
363		};
364
365		};
366
367		export const setData = ({ data, stateKey, editMode }) => ({
368		type: SET_DATA, data, stateKey, editMode
369		});
370
371		export const setTreeData = ({
372		data, stateKey, showTreeRootNode, partial, parentId, editMode
373		}) => {
374
375		// if this is a partial update to
376		// a tree grid, dispatch separate action;
377		if (partial) {
378		return {
379		type: SET_TREE_DATA_PARTIAL,
380		data: data,
381		stateKey,
382		gridType: 'tree',
383		showTreeRootNode,
384		parentId
385		};
386		}
387
388		let flat = treeToFlatList(data);
389
390		// remove root node
391		if (!showTreeRootNode) {
392		flat = flat.shift();
393		}
394
395		return {
396		type: SET_DATA,
397		data: flat,
398		stateKey,
399		gridType: 'tree',
400		treeData: data,
401		editMode
402		};
403		};
404
405		export const setTreeNodeVisibility = ({
406		id, visible, stateKey, showTreeRootNode
407		}) => ({
408		type: SET_TREE_NODE_VISIBILITY,
409		id,
410		visible,
411		stateKey,
412		showTreeRootNode
413		});
414
415		export const moveNode = ({
416		stateKey, current, next, showTreeRootNode
417		}) => ({
418		type: MOVE_NODE,
419		stateKey,
420		current,
421		next,
422		showTreeRootNode
423		});
424
425		export const setHeaderVisibility = ({ hidden, stateKey }) => ({
426		type: HIDE_HEADER, headerHidden: hidden, stateKey
427		});
428

bencripps / react-redux-grid

GitHub Access Token became invalid

Push — master ( 55f45f...84a66e )

GridActions.js ➔ getAsyncData B

Complexity

Size

Duplication

Importance

2 Functions

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like